Mutual exclusion (mutex) locks are the traditional primitive used to provide atomicity in software execution. For example, a set of threads performing indirect updates on a storage array can be parallelized using locks. The overhead for grabbing a lock can be very large compared to the real work being done, however, making execution of certain code using the locks too slow in practice. Another option to provide the atomicity is to parallelize the code using transactions. In this case, the acquiring and release of the lock is replaced with transaction begin and transaction end instructions. Transactions may have lower overhead than locks, making this transactional parallelization more reasonable. In conventional systems, however, hardware support for transactions typically still carries significant overhead. Thus, even using transactions, parallelization of the code is usually not very fast.